home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_binascii.py < prev    next >
Text File  |  2005-10-18  |  6KB  |  166 lines
  1. """Test the binascii C module."""
  2.  
  3. from test import test_support
  4. import unittest
  5. import binascii
  6.  
  7. class BinASCIITest(unittest.TestCase):
  8.  
  9.     # Create binary test data
  10.     data = "The quick brown fox jumps over the lazy dog.\r\n"
  11.     # Be slow so we don't depend on other modules
  12.     data += "".join(map(chr, xrange(256)))
  13.     data += "\r\nHello world.\n"
  14.  
  15.     def test_exceptions(self):
  16.         # Check module exceptions
  17.         self.assert_(issubclass(binascii.Error, Exception))
  18.         self.assert_(issubclass(binascii.Incomplete, Exception))
  19.  
  20.     def test_functions(self):
  21.         # Check presence of all functions
  22.         funcs = []
  23.         for suffix in "base64", "hqx", "uu", "hex":
  24.             prefixes = ["a2b_", "b2a_"]
  25.             if suffix == "hqx":
  26.                 prefixes.extend(["crc_", "rlecode_", "rledecode_"])
  27.             for prefix in prefixes:
  28.                 name = prefix + suffix
  29.                 self.assert_(callable(getattr(binascii, name)))
  30.                 self.assertRaises(TypeError, getattr(binascii, name))
  31.         for name in ("hexlify", "unhexlify"):
  32.             self.assert_(callable(getattr(binascii, name)))
  33.             self.assertRaises(TypeError, getattr(binascii, name))
  34.  
  35.     def test_base64valid(self):
  36.         # Test base64 with valid data
  37.         MAX_BASE64 = 57
  38.         lines = []
  39.         for i in range(0, len(self.data), MAX_BASE64):
  40.             b = self.data[i:i+MAX_BASE64]
  41.             a = binascii.b2a_base64(b)
  42.             lines.append(a)
  43.         res = ""
  44.         for line in lines:
  45.             b = binascii.a2b_base64(line)
  46.             res = res + b
  47.         self.assertEqual(res, self.data)
  48.  
  49.     def test_base64invalid(self):
  50.         # Test base64 with random invalid characters sprinkled throughout
  51.         # (This requires a new version of binascii.)
  52.         MAX_BASE64 = 57
  53.         lines = []
  54.         for i in range(0, len(self.data), MAX_BASE64):
  55.             b = self.data[i:i+MAX_BASE64]
  56.             a = binascii.b2a_base64(b)
  57.             lines.append(a)
  58.  
  59.         fillers = ""
  60.         valid = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/"
  61.         for i in xrange(256):
  62.             c = chr(i)
  63.             if c not in valid:
  64.                 fillers += c
  65.         def addnoise(line):
  66.             noise = fillers
  67.             ratio = len(line) // len(noise)
  68.             res = ""
  69.             while line and noise:
  70.                 if len(line) // len(noise) > ratio:
  71.                     c, line = line[0], line[1:]
  72.                 else:
  73.                     c, noise = noise[0], noise[1:]
  74.                 res += c
  75.             return res + noise + line
  76.         res = ""
  77.         for line in map(addnoise, lines):
  78.             b = binascii.a2b_base64(line)
  79.             res += b
  80.         self.assertEqual(res, self.data)
  81.  
  82.         # Test base64 with just invalid characters, which should return
  83.         # empty strings. TBD: shouldn't it raise an exception instead ?
  84.         self.assertEqual(binascii.a2b_base64(fillers), '')
  85.  
  86.     def test_uu(self):
  87.         MAX_UU = 45
  88.         lines = []
  89.         for i in range(0, len(self.data), MAX_UU):
  90.             b = self.data[i:i+MAX_UU]
  91.             a = binascii.b2a_uu(b)
  92.             lines.append(a)
  93.         res = ""
  94.         for line in lines:
  95.             b = binascii.a2b_uu(line)
  96.             res += b
  97.         self.assertEqual(res, self.data)
  98.  
  99.         self.assertEqual(binascii.a2b_uu("\x7f"), "\x00"*31)
  100.         self.assertEqual(binascii.a2b_uu("\x80"), "\x00"*32)
  101.         self.assertEqual(binascii.a2b_uu("\xff"), "\x00"*31)
  102.         self.assertRaises(binascii.Error, binascii.a2b_uu, "\xff\x00")
  103.         self.assertRaises(binascii.Error, binascii.a2b_uu, "!!!!")
  104.  
  105.         self.assertRaises(binascii.Error, binascii.b2a_uu, 46*"!")
  106.  
  107.     def test_crc32(self):
  108.         crc = binascii.crc32("Test the CRC-32 of")
  109.         crc = binascii.crc32(" this string.", crc)
  110.         self.assertEqual(crc, 1571220330)
  111.  
  112.         self.assertRaises(TypeError, binascii.crc32)
  113.  
  114.     # The hqx test is in test_binhex.py
  115.  
  116.     def test_hex(self):
  117.         # test hexlification
  118.         s = '{s\005\000\000\000worldi\002\000\000\000s\005\000\000\000helloi\001\000\000\0000'
  119.         t = binascii.b2a_hex(s)
  120.         u = binascii.a2b_hex(t)
  121.         self.assertEqual(s, u)
  122.         self.assertRaises(TypeError, binascii.a2b_hex, t[:-1])
  123.         self.assertRaises(TypeError, binascii.a2b_hex, t[:-1] + 'q')
  124.  
  125.         # Verify the treatment of Unicode strings
  126.         if test_support.have_unicode:
  127.             self.assertEqual(binascii.hexlify(unicode('a', 'ascii')), '61')
  128.  
  129.     def test_qp(self):
  130.         # A test for SF bug 534347 (segfaults without the proper fix)
  131.         try:
  132.             binascii.a2b_qp("", **{1:1})
  133.         except TypeError:
  134.             pass
  135.         else:
  136.             self.fail("binascii.a2b_qp(**{1:1}) didn't raise TypeError")
  137.         self.assertEqual(binascii.a2b_qp("= "), "")
  138.         self.assertEqual(binascii.a2b_qp("=="), "=")
  139.         self.assertEqual(binascii.a2b_qp("=AX"), "=AX")
  140.         self.assertRaises(TypeError, binascii.b2a_qp, foo="bar")
  141.         self.assertEqual(binascii.a2b_qp("=00\r\n=00"), "\x00\r\n\x00")
  142.         self.assertEqual(
  143.             binascii.b2a_qp("\xff\r\n\xff\n\xff"),
  144.             "=FF\r\n=FF\r\n=FF"
  145.         )
  146.         self.assertEqual(
  147.             binascii.b2a_qp("0"*75+"\xff\r\n\xff\r\n\xff"),
  148.             "0"*75+"=\r\n=FF\r\n=FF\r\n=FF"
  149.         )
  150.  
  151.     def test_empty_string(self):
  152.         # A test for SF bug #1022953.  Make sure SystemError is not raised.
  153.         for n in ['b2a_qp', 'a2b_hex', 'b2a_base64', 'a2b_uu', 'a2b_qp',
  154.                   'b2a_hex', 'unhexlify', 'hexlify', 'crc32', 'b2a_hqx',
  155.                   'a2b_hqx', 'a2b_base64', 'rlecode_hqx', 'b2a_uu',
  156.                   'rledecode_hqx']:
  157.             f = getattr(binascii, n)
  158.             f('')
  159.         binascii.crc_hqx('', 0)
  160.  
  161. def test_main():
  162.     test_support.run_unittest(BinASCIITest)
  163.  
  164. if __name__ == "__main__":
  165.     test_main()
  166.